//数组的高阶函数：数组的返回值或者参数是函数
// let arr = [1, 200, 500, 75, 85, 97, 66, 45, 34, 23, 21, 100];
// for (let i = 0; i < arr.length; i++){
//     if (arr[i] > 100){
//         console.log(arr[i]);
//     }
// }
// console.log("----------------------");
// for (let i = 0; i < arr.length; i++){
//     if (arr[i] > 50){
//         console.log(arr[i]);
//     }
// }

// function filterDayu(num) {
//     for (let i = 0; i < arr.length; i++){
//         if (arr[i] > num){
//             console.log(arr[i]);
//         }
//     }
//     console.log("----------------------");
// }
// filterDayu(50);
//
// function filterXiaoyu(num) {
//     for (let i = 0; i < arr.length; i++){
//         if (arr[i] < num){
//             console.log(arr[i]);
//         }
//     }
//     console.log("----------------------");
// }
// filterXiaoyu(80);


// let arr = [1, 200, 500, 75, 85, 97, 66, 45, 34, 23, 21, 100];
// function filter(num, func) {
//     for (let i = 0; i < arr.length; i++) {
//         if (func(arr[i], num)) {
//             console.log(arr[i]);
//         }
//     }
//     console.log("----------------------");
// }
// filter(100, function test(a, b) {
//     return a > b;
// })
// filter(80, function test(a, b) {
//     return a < b;
// })

// let arr = [1, 200, 500, 75, 85, 97, 66, 45, 34, 23, 21, 100];
// arr.sort()  //默认是按照Unicode编码排序
// arr.sort(function (a, b) {
//     // return a - b;   //从小到大
//     return b - a;   //从大到小
// });
// console.log(arr);


//数组的遍历  for ... in ...  for ... of ...
// let arr = [1, 200, 500, 75, 85, 97, 66, 45, 34, 23, 21, 100];
// for (let i = 0; i < arr.length; i++) {
//     console.log(arr[i]);
// }

// let arr = [
//     [1, 2, 3],
//     [4, 5, 6],
//     [7]
// ], c = 0;
// for (let i = 0; i < arr.length; i++) {
//     for (let j = 0; j < arr[i].length; j++) {
//         console.log(arr[i][j]);
//         c += arr[i][j]
//     }
// }
// console.log(c);
//
// for (const arrKey in arr) {
//     console.log(arrKey);  //获取的是数组的下标(索引)
//     console.log(arr[arrKey]);
// }
// for (const arrElement of arr) {
//     console.log(arrElement);  //获取的是数组的元素
// }


// let obj={x:200,y:300};
// for (const objKey in obj) {
//     console.log(objKey);  //获取的是对象的属性名
// }

//for ... of ...可以遍历实现了iterable的任意对象 要使用的话必须实现iterable接口 否则无法使用
// for (const objElement of obj) {
//     console.log(objElement);
// }


//map(function())->这个也算高阶函数
// let  arr = [1,55,300,76,39,85,100];
// let newArr =arr.map(function (value, index,array){
//     console.log(value);  //相对于数组的遍历
//     return value+10;   //相当于对数组的每个元素进行操作 返回一个新数组 不改变原数组的值
// });
// console.log(newArr);

// forEach(function())
// let  arr = [1,55,300,76,39,85,100];
// arr.forEach(function (value, index,array){
//     console.log(value);  //相对于数组的遍历
// });
// console.log(arr);

// //filter 它接收一个回调函数作为参数，并根据回调函数返回值是 true 还是 false 来决定是否保留数组中的元素。
// let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// // 使用 filter 函数过滤出偶数
// let evenNumbers = numbers.filter(number => number % 2 === 0);   //相当于number % 2 === 0) ? true : false
// console.log(evenNumbers);


// //数组作为函数的参数或者返回值
// let arr = [100,200,300];
// let person = {name:'luojinsheng'};
// function func(args,obj) {
//     args[2] = 1000;
//     obj.name = 'luodada';
// }
// func(arr,person)  //实际上是在传入一个指向原始数组和原始对象的指针 因此原数组和原对象都会改变
// console.log(arr);
// console.log(person);


// function func() {
//     let arr = [100,200,300];
//     arr[2] = 1000;
//     return arr
// }
// let newArr= func()
// console.log(newArr);
// newArr[2] = 300;
// console.log(newArr);


// //arguments:是一个类数组对象 用来存储函数的实参 arguments和数组相似 可以通过索引来读取元素
// function func(num) {
//     console.log(arguments);
//     console.log(arguments[2]);
//     console.log(arguments.length);
//     //遍历传入的实参
//     for (let i = 0; i < arguments.length; i++){
//         console.log(arguments[i]);
//     }
//     let arr = Array.prototype.slice.call(arguments)  //slice()切片函数
//     console.log(arr);
//     console.log('============================');
// }
//
// func(100)           //{ '0': 100 }
// func(100, 200)       //{ '0': 100, '1': 200 }
// func(100, 200, 300)   //{ '0': 100, '1': 200, '2': 300 }


// //可变参数与展开运算符
// function func(a,...arr) {  //可变参数可以接收任意数量实参，会存储到一个数组当中
//     console.log(a,arr)
// }
// func(100)
// func(100, 200)
// func(100, 200, 300)

// let arr = [100,200,300];
// let newArr1 = arr;  //浅拷贝：实际上是在创建一个指向原始数组的指针
// let newArr2 = [...arr];  //展开运算符 ...
// console.log(newArr1);
// arr[2]=500;
// console.log(newArr1); //newArr1数组里的值会随着arr数组里的值改变


//数组解构
// let arr = [100,200,300];
// let a = arr[0];
// let b = arr[1];
// let c = arr[2];
// console.log(a,b,c);

// let [a1,b1,c1] = arr;
// console.log(a1,b1,c1); //100 200 300

// let [a1,b1] = arr;
// console.log(a1,b1);  //100 200

// let [a1,b1,c1,d1] = arr;
// console.log(a1,b1,c1,d1);  //100 200 300 undefined

// let [a1,b1,c1,d1=888] = arr;
// console.log(a1,b1,c1,d1);  //100 200 300 888

// let [a1,...b1] = arr;
// console.log(a1,b1);

// //函数参数直接解构
// let arr2 = [1, 2, 3, 4, 5, 6, 7, 8];
// function test([a1, b1, c1]) {
//     console.log(a1, b1, c1);
//
// }
// test(arr2)  //相当于 [a1,b1,c1] = arr2

// //变量的交换
// let a = 100;
// let b = 200;
//
// // let temp = a;
// // a = b;
// // b = temp;
// // console.log(a, b);
//
// [a, b] = [b, a]   //[b, a] = [a, b]
// console.log(a, b);

// let arr = [64,96,17,36,32,94,81,1,45,56,39,27,57,27,74,22,56,6,97,27]
// console.log(arr.length);
// let newArr1 = arr.slice(0,10).sort(function (a,b) {
//     return a-b;
// })
// let newArr2 = arr.slice(10).sort(function (a,b) {
//     return b-a;
// })
// let newArr3 = newArr1.concat(newArr2)
// console.log(newArr3);














